#include <iostream>
using namespace std;

class stack
{
public:

	stack(int capacity = 10)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == NULL)
		{
			perror("malloc fali\n");
			exit(-1);
		}

		_size = 0;
		_capacity = capacity;
	}

	void print()
	{
		cout << _a << " " << _size << " " << _capacity << endl;
	}

private:
	int* _a;
	int _size;
	int _capacity;
};

class A
{
public:
	A(int a, int& ref)
		:_ref(ref)
		, _n(a)
		, AA(100)
		,_d(20)
	{}

	void print()
	{
		cout << _ref << " " << _n << " " << _d << endl;
	}
private:
	//没有默认拷贝函数
	stack AA;

	//在定义的时候需要初始化
	int& _ref;  //引用
	const int _n;  //const 修饰

	int _d = 1;  //缺省值是传给初始化列表的
};

class myqueue
{
public:

	//没有初始化列表 编译器也会自动走一遍初始化列表 调用默认构造函数
	//会自动调用自定义类型内部的构造函数进行初始化
	/*myqueue()
	{

	}*/

	//自己实现自定义类型的初始化
	myqueue()
		:q1(10)
		,q2(100)
	{}
private:
	stack q1;
	stack q2;
};

class B
{
public:
	B()
	{
		++_scount;
	}

	B(const B& d)
	{
		++_scount;
	}

	~B()
	{
		--_scount;
	}

	//非静态成员函数内可以访问静态成员函数
	void func1()
	{
		Getcount();
	}

	void func2()
	{

	}

	//静态成员函数 没有this指针 函数体内不能访问非静态成员变量 类外通过类域和访问限定符就可以访问
	static int Getcount()
	{
		//静态成员函数内不能访问非静态成员函数 因为没有this指针可以调用静态成员函数
		//func2();
		return _scount;
	}
private:
	//成员变量 —— 每个类都有一个成员变量，存储在对象中
	int _a1 = 1;
	int _a2 = 2;

	//静态成员变量 —— 属于类，是每个类对象共有的，存储在静态区
	//不能给缺省值 因为它没有初始化列表
	static int _scount;
};

//类内声明 类外定义
int B::_scount = 0;

void func()
{
	//静态对象只会创建依次
	static B bb3;
	cout << __LINE__ << ":" << B::Getcount() << endl;  //3
}

B bb1;

class C
{
public:
	//explicit C(int c = 1)  可以防止隐式类型的转换
	C(int c)
		:_c(c)
	{
		cout << "C(int c)" << endl;
	}

	C(const C& c)
		:_c(c._c)
	{
		cout << "C(const C& c)" << endl;
	}
private:
	int _c = 0;
};

//定义一个类，在类外只能在栈上创建对象
//定义一个类，在类外只能在堆上创建对象
class D
{
public:
	static D Getstackobj()
	{
		D dd1;
		return dd1;
	}

	static D* Getheapobj(int a,int b)
	{
		D* ptr = new D;
		ptr->_d1 = a;
		ptr->_d2 = b;
		return ptr;
	}

	void print()
	{
		cout << _d1 << " " << _d2 << endl;
	}

private:
	D()
	{}
	int _d1 = 1;
	int _d2 = 2;
};

int main()
{
	cout << __LINE__<< ":" << B::Getcount() << endl;  //1

	int x = 5;
	A aa1(10, x);
	aa1.print();

	B bb2;
	cout << __LINE__ << ":" << B::Getcount() << endl;  //2

	myqueue Q1;

	func();
	func();

	//隐式类型转换  整型转化为自定义类型
	C cc1 = 2;  //2先调用构造函数构造一个C的临时对象，再用临时对象拷贝构造cc1--编译器优化：用2直接构造
	//error C2440: “初始化”: 无法从“int”转换为“A &”
	//C& cc2 = 2;
	const C& cc2 = 2;  //临时对象具有常性，要用const修饰，权限缩小

	//在堆上创建对象
	D* ptr = D::Getheapobj(10,20);
	ptr->print();
	//在栈上创建对象
	D dd1 = D::Getstackobj();
	dd1.print();


	return 0;
}